"""
智能体工厂模块
负责创建和管理各种智能体实例，提供统一的智能体创建接口

作者: 架构重构优化
日期: 2025-01-05
"""

import logging
from typing import Dict, Any, Optional
from langchain_openai import ChatOpenAI
from langgraph.checkpoint.memory import MemorySaver
from langgraph_supervisor import create_supervisor
from .config_manager import ConfigManager

logger = logging.getLogger(__name__)

class AgentFactory:
    """
    智能体工厂类
    负责创建和配置各种智能体实例
    """
    
    def __init__(self, config: ConfigManager):
        """
        初始化智能体工厂
        
        Args:
            config: 配置管理器实例
        """
        self.config = config
        self.model = None
        self.checkpointer = None
        self.text2sql_agent = None
        self.dingtalk_agent = None
        self.supervisor_app = None
        
        # 初始化基础组件
        self._init_model()
        self._init_checkpointer()
        
        logger.info("智能体工厂初始化完成")

    def _init_model(self):
        """初始化语言模型"""
        try:
            self.model = ChatOpenAI(
                model=self.config.model.base_model,
                api_key=self.config.model.openai_api_key,
                base_url=self.config.model.openai_api_base,
                temperature=self.config.model.temperature,
                max_tokens=self.config.model.max_tokens
            )
            logger.info(f"语言模型初始化成功: {self.config.model.base_model}")
        except Exception as e:
            logger.error(f"语言模型初始化失败: {e}")
            raise

    def _init_checkpointer(self):
        """初始化记忆检查点"""
        try:
            self.checkpointer = MemorySaver()
            logger.info("记忆检查点初始化成功")
        except Exception as e:
            logger.error(f"记忆检查点初始化失败: {e}")
            raise

    def create_text2sql_agent(self):
        """
        创建 Text2SQL 智能体
        
        Returns:
            Text2SQL 智能体实例
        """
        if self.text2sql_agent is None:
            try:
                from text2sql.text2sql_agent import get_text2sql_agent
                
                text2sql_factory = get_text2sql_agent()
                self.text2sql_agent = text2sql_factory.get_agent()
                
                logger.info("Text2SQL 智能体创建成功")
            except Exception as e:
                logger.error(f"Text2SQL 智能体创建失败: {e}")
                # 创建一个模拟智能体
                self.text2sql_agent = self._create_mock_text2sql_agent()
        
        return self.text2sql_agent

    def create_dingtalk_agent(self):
        """
        创建钉钉智能体
        
        Returns:
            钉钉智能体实例
        """
        if self.dingtalk_agent is None:
            try:
                from .dingtalk_agent import create_dingtalk_agent
                
                # 让钉钉智能体自己初始化工具
                self.dingtalk_agent = create_dingtalk_agent()
                
                logger.info("钉钉智能体创建成功")
            except Exception as e:
                logger.error(f"钉钉智能体创建失败: {e}")
                # 创建一个空的钉钉智能体
                self.dingtalk_agent = self._create_mock_dingtalk_agent()
        
        return self.dingtalk_agent

    def create_supervisor_workflow(self, enhanced_mode: bool = False):
        """
        创建 Supervisor 工作流
        
        Args:
            enhanced_mode: 是否使用增强模式
            
        Returns:
            编译后的 Supervisor 应用
        """
        if self.supervisor_app is None:
            try:
                # 确保智能体已创建
                text2sql_agent = self.create_text2sql_agent()
                dingtalk_agent = self.create_dingtalk_agent()
                
                # 创建 Supervisor 提示词
                supervisor_prompt = self._create_supervisor_prompt()
                
                # 创建工作流
                if enhanced_mode:
                    workflow = self._create_enhanced_supervisor(
                        [text2sql_agent], dingtalk_agent, supervisor_prompt
                    )
                else:
                    workflow = create_supervisor(
                        agents=[text2sql_agent],
                        model=self.model,
                        prompt=supervisor_prompt,
                        dingtalk_agent=dingtalk_agent
                    )
                
                # 编译工作流
                self.supervisor_app = workflow.compile(checkpointer=self.checkpointer)
                
                logger.info(f"Supervisor 工作流创建成功 (增强模式: {enhanced_mode})")
            except Exception as e:
                logger.error(f"Supervisor 工作流创建失败: {e}")
                raise
        
        return self.supervisor_app

    def _create_supervisor_prompt(self) -> str:
        """创建 Supervisor 提示词"""
        return """你是钉钉机器人小智，一个专业的AI助手，负责智能路由和协调。

🎯 **你的核心职责**：
1. 智能分析用户请求，准确路由到合适的专业智能体
2. 处理问候和功能介绍
3. 协调多个专业智能体为用户提供服务

🤖 **可用的专业智能体**：
1. **text2sql_agent** - 电影数据库专家：
   - 电影信息查询、演员资料、票房统计
   - 数据分析、分类查询、客户信息
   - 处理所有与电影数据库相关的问题

2. **dingtalk_agent** - 钉钉办公专家：
   - 待办事项管理：创建、查看、完成任务
   - 日程安排：查看日程、创建会议
   - 联系人查询：搜索同事信息
   - 处理所有与钉钉办公相关的功能

🔄 **路由原则**：
- 问候和功能介绍：由你直接处理
- 电影/数据库相关：路由到 text2sql_agent
- 钉钉/办公相关：路由到 dingtalk_agent
- 不确定的查询：默认路由到 text2sql_agent

💬 **交互风格**：
- 保持友好、专业的语调
- 用自然语言回答，避免技术术语
- 主动询问澄清不明确的问题
- 专注于用户价值和解决方案

你的目标是为用户提供最佳的服务体验，通过智能路由确保每个请求都得到最专业的处理。"""

    def _create_enhanced_supervisor(self, agents, dingtalk_agent, prompt):
        """创建增强版 Supervisor（预留接口）"""
        try:
            # 尝试使用增强记忆集成
            from enhanced_memory.langgraph_integration import create_enhanced_supervisor
            
            return create_enhanced_supervisor(
                agents=agents,
                model=self.model,
                prompt=prompt,
                dingtalk_agent=dingtalk_agent
            )
        except ImportError:
            logger.warning("增强记忆集成不可用，使用标准 Supervisor")
            return create_supervisor(
                agents=agents,
                model=self.model,
                prompt=prompt,
                dingtalk_agent=dingtalk_agent
            )

    def _create_mock_text2sql_agent(self):
        """创建模拟的 Text2SQL 智能体"""
        class MockText2SQLAgent:
            def __init__(self):
                self.name = "text2sql_agent"
            
            def process_query(self, question: str):
                return {
                    "success": False,
                    "messages": [],
                    "message": "Text2SQL 功能暂时不可用"
                }
        
        return MockText2SQLAgent()

    def _create_mock_dingtalk_agent(self):
        """创建模拟的钉钉智能体"""
        class MockDingTalkAgent:
            def __init__(self):
                self.name = "dingtalk_agent"
                self.dingtalk_tools = []
            
            def process_request(self, request: str, user_id: str):
                return {
                    "output": "钉钉功能暂时不可用",
                    "success": False
                }
        
        return MockDingTalkAgent()

    def reset(self):
        """重置工厂，清除所有缓存的实例"""
        self.text2sql_agent = None
        self.dingtalk_agent = None
        self.supervisor_app = None
        logger.info("智能体工厂已重置")

    def get_stats(self) -> Dict[str, Any]:
        """获取工厂统计信息"""
        return {
            "model_name": self.config.model.base_model,
            "text2sql_agent_created": self.text2sql_agent is not None,
            "dingtalk_agent_created": self.dingtalk_agent is not None,
            "supervisor_app_created": self.supervisor_app is not None,
            "checkpointer_available": self.checkpointer is not None
        }
